home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Systemmonitors / RSys / RSysSrc.lha / RSysIntuiCtrl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-24  |  18.4 KB  |  815 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysIntuiCtrl.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    APTR LockWindow ( struct Window *win );
  12. *    char *gadgetbuff ( struct Gadget *gad );
  13. *    int OpenASysWindow ( int (*func )(void ), int kill );
  14. *    long SetupScreen ( void );
  15. *    struct Screen *FindFrontPubScr ( struct Screen *activescr );
  16. *    void AdjustWindowDimensions ( struct Screen *Scr , UWORD WinLeftEdge , UWORD WinTopEdge , UWORD WinWidth , UWORD WinHeight , UWORD *NewWinLeftEdge , UWORD *NewWinTopEdge , UWORD *NewWinWidth , UWORD *NewWinHeight );
  17. *    void CenterWindow ( struct Screen *scr , UWORD *top , UWORD *left , UWORD width , UWORD height );
  18. *    void ClearIntuiMsgPort ( struct Window *wnd );
  19. *    void CloseASysWindow ( struct Window **wind , struct Gadget **windgadlist , struct Menu **windmenus );
  20. *    void CloseDownScreen ( void );
  21. *    void DisableSysRequest ( int disable );
  22. *    void EmptyListView ( void );
  23. *    void EnableGadget ( struct Window *Wnd , struct Gadget *gad , int on_off );
  24. *    void InitListView ( struct Window *wind , struct Gadget *gad , struct List *list , int top );
  25. *    void LockMainWindow ( int on );
  26. *    void makelabelvisible ( struct Gadget *gad );
  27. *    void MakePattern ( struct Window *wind );
  28. *    void MakeWindowRefresh ( struct Window *window );
  29. *    void OpenMainWindow ( void );
  30. *    void PrintHeader ( enum ListTypes type , char *text );
  31. *    void PrintInfo ( char *text , int speakit , int waitit );
  32. *    void PrintStatistics ( void );
  33. *    void RefreshListView ( void );
  34. *    void RefreshMainWindowPattern ( void );
  35. *    void RefreshRastPort ( struct Window *wind , struct Gadget **gads , int *gadnum , int cnt , int SaveGad , struct Gadget *GadgetList );
  36. *    void RefreshWindowAndGadgets ( struct Window *wind );
  37. *    void UnlockWindow ( APTR req );
  38. *    WORD MyEasyRequest ( struct Window *wind , UBYTE *title , UBYTE *Gadgets , UBYTE *Body , ...);
  39. *
  40. *      --- Lokale  Routinen ---
  41. *
  42. *    static void FillGadget ( struct Window *wind , struct Gadget *gad , BYTE SaveGad );
  43. *
  44. * Bemerkungen:
  45. *      Intuition Supportroutinen für die Verwaltung der Intuitionobjekte
  46. *      des Hauptwindows von RSys.
  47. *      (Aus RSysUtils.c ausgelagert)
  48. *
  49. * Erstellungsdatum:
  50. *      25-Jun-93     Rolf Böhme
  51. *
  52. * Änderungen:
  53. *      25-Jun-93     Rolf Böhme      Erstellung
  54. *      25-Jun-93     Rolf Böhme      makelabelvisible() hinzugefügt
  55. *
  56. ***************************************************************************
  57. */
  58.  
  59. #include "RSys.h"
  60.  
  61.  
  62. /********************************************************************
  63.  *                                                                  *
  64.  *       ***************** Gadget Routinen *****************        *
  65.  *                                                                  *
  66.  ********************************************************************/
  67.  
  68.     /*
  69.      * EnableGadget() schaltet ein Gadget auf einem Window ein oder
  70.      * aus
  71.      */
  72. void
  73. EnableGadget(struct Window *Wnd, struct Gadget *gad, int on_off)
  74. {
  75.     DPOS;
  76.  
  77.     GT_SetGadgetAttrs(gad, Wnd, NULL, GA_Disabled, NOT(on_off), TAG_DONE);
  78.  
  79.     return;
  80. }
  81.  
  82. void
  83. makelabelvisible(struct Gadget *gad)
  84. {
  85.     extern int bgc, bpc;
  86.  
  87.     if(gad->GadgetText)
  88.     {
  89.         gad->GadgetText->DrawMode |= JAM2;
  90.         gad->GadgetText->BackPen    = 0;
  91.         gad->GadgetText->FrontPen    = 1;
  92.     }
  93.  
  94.     return;
  95. }
  96.  
  97.     /*
  98.      * gadgetbuff() ermittelt den String, der in einem Stringgadget
  99.      * steht
  100.      */
  101. char *
  102. gadgetbuff(struct Gadget *gad)
  103. {
  104.     DPOS;
  105.  
  106.     return ((char *)(((struct StringInfo *) (gad->SpecialInfo))->Buffer));
  107. }
  108.  
  109.     /*
  110.      * FillGadget() löscht den Hintergrund eines Boolean-Gadgets
  111.      */
  112. static void
  113. FillGadget( struct Window *wind, struct Gadget *gad, BYTE SaveGad )
  114. {
  115.     BYTE GadType = (BYTE)gad->GadgetType;
  116.     UWORD pos;
  117.  
  118.    if(SaveGad) pos = RemoveGadget(wind,gad);
  119.  
  120.     if(GadType == GTYP_STRGADGET)
  121.         EraseRect( wind->RPort,(long)gad->LeftEdge - 2,
  122.                                       (long)gad->TopEdge - 1,
  123.                                       (long)(gad->LeftEdge + gad->Width + 1),
  124.                                       (long)(gad->TopEdge + gad->Height) );
  125.     else EraseRect( wind->RPort,(long)gad->LeftEdge,
  126.                                (long)gad->TopEdge,
  127.                                (long)(gad->LeftEdge + gad->Width - 1),
  128.                                (long)(gad->TopEdge + gad->Height - 1) );
  129.  
  130.     if(SaveGad) AddGadget(wind,gad,(ULONG)pos);
  131.  
  132.     return;
  133. }
  134.  
  135.     /*
  136.      * InitListView() initialisiert ein ListView in einem Fenster
  137.      * mit einer anzugebenden Liste. Ist die Liste NULL, wird das
  138.      * ListView systemgemäß mit ~0 initialisiert
  139.      */
  140. void
  141. InitListView(struct Window *wind, struct Gadget *gad, struct List *list, int top)
  142. {
  143.     struct List *lvlist = (list != NULL) ? list : (struct List *)(~0);
  144.  
  145.     DPOS;
  146.  
  147.     if(list != NULL) GT_SetGadgetAttrs(gad, wind,NULL,GTLV_Labels, (~0), TAG_DONE);
  148.  
  149.     if(top == UNSETLVPOS) GT_SetGadgetAttrs(gad, wind, NULL, GTLV_Labels, lvlist, TAG_DONE);
  150.     else
  151.         GT_SetGadgetAttrs(gad, wind,
  152.                                 NULL,
  153.                                 GTLV_Labels, lvlist,
  154.                                 GTLV_Top, top,
  155.                                 GTLV_Selected, (~0),
  156.                                 TAG_DONE);
  157. }
  158.  
  159.     /*
  160.      * RefreshListView() erneuert das ListView auf dem Hauptwindow
  161.      */
  162. void
  163. RefreshListView(void)
  164. {
  165.     DPOS;
  166.  
  167.     InitListView(SysWnd,SysGadgets[GD_ListeLV],&ListeLVList,UNSETLVPOS);
  168.     return;
  169. }
  170.  
  171.     /*
  172.      * EmptyListView() löscht die Einträge des Haupt-ListViews
  173.      */
  174. void
  175. EmptyListView(void)
  176. {
  177.     DPOS;
  178.  
  179.     InitListView(SysWnd,SysGadgets[GD_ListeLV],NULL,0);
  180.  
  181.     NewList(&ListeLVList);
  182.  
  183.     RefreshListView();
  184.  
  185.     GT_RefreshWindow(SysWnd, NULL);
  186.  
  187.     return;
  188. }
  189.  
  190. /********************************************************************
  191.  *                                                                  *
  192.  *       ***************** Window Routinen *****************        *
  193.  *                                                                  *
  194.  ********************************************************************/
  195.  
  196.     /*
  197.      * LockWindow() öffnet einen Requester der Größe 1x1 und sperrt
  198.      * das Window damit gegen Eingaben
  199.      */
  200. APTR
  201. LockWindow(struct Window * win)
  202. {
  203.     struct Requester *req = NULL;
  204.  
  205.     DPOS;
  206.  
  207.    if(!win) return NULL;
  208.  
  209.     req = (struct Requester *) MyAllocVec(sizeof(struct Requester),MEMF_ANY | MEMF_CLEAR, NO_KILL);
  210.     if (req)
  211.     {
  212.         req->LeftEdge = 1;
  213.         req->TopEdge = 1;
  214.         req->Width = 1;
  215.         req->Height = 1;
  216.         req->Flags = SIMPLEREQ | NOREQBACKFILL;
  217.  
  218.         Request(req, win);
  219.     }
  220.  
  221.     return ((APTR) req);
  222. }
  223.  
  224.     /*
  225.      * UnlockWindow() gibt ein mit LockWindow() gesperrtes Window
  226.      * wieder frei. Es ist dann wieder für Benutzereingaben
  227.      * zugänglich
  228.      */
  229. void
  230. UnlockWindow(APTR req)
  231. {
  232.     DPOS;
  233.  
  234.     if (req)
  235.     {
  236.         EndRequest((struct Requester *) req, ((struct Requester *) req)->RWindow);
  237.         MyFreeVec(req);
  238.  
  239.       req = NULL;
  240.     }
  241.  
  242.     return;
  243. }
  244.  
  245. void
  246. LockMainWindow(int on)
  247. {
  248.    static APTR req = NULL;
  249.  
  250.    if (on) req = LockWindow(SysWnd);
  251.    else
  252.    {
  253.       UnlockWindow(req);
  254.       RefreshMainWindowPattern();
  255.       PrintStatistics();
  256. /*      RefreshList(LastID);*/
  257.    }
  258.  
  259.    return;
  260. }
  261.  
  262.     /*
  263.      * MakeWindowRefresh() führt die Standard-System-Routinen zur
  264.      * Erneuerung eines Windows aus
  265.      */
  266. void
  267. MakeWindowRefresh(struct Window *window)
  268. {
  269.     GT_BeginRefresh(window);
  270.     GT_EndRefresh(window, TRUE);
  271.  
  272.     return;
  273. }
  274.  
  275. void
  276. MakePattern(struct Window *wind)
  277. {
  278.    struct RastPort *RP = wind->RPort;
  279.  
  280.    if(wind != SysWnd && (wind->Flags & WFLG_ZOOMED)) return;
  281.  
  282.    if(bgc || bpc)
  283.    {
  284.        SetAfPt(RP,(USHORT *)&bpp,1L);
  285.  
  286.        SetAPen(RP,bpc);
  287.        SetBPen(RP,bgc);
  288.  
  289.        SetDrMd(RP,JAM2);
  290.  
  291.        RectFill(RP,(long)OffX,(long)OffY,
  292.                        (long)wind->Width - Scr->WBorRight,
  293.                      (long)wind->Height - Scr->WBorBottom + 1 - wind->BorderBottom);
  294.  
  295.        SetAfPt(RP,NULL,NULL);
  296.    }
  297.    else
  298.    {
  299.        SetAPen(RP,0);
  300.        SetBPen(RP,0);
  301.  
  302.        RectFill(RP,(long)OffX,(long)OffY,
  303.                        (long)wind->Width - Scr->WBorRight,
  304.                      (long)wind->Height - Scr->WBorBottom + 1 - wind->BorderBottom);
  305.    }
  306.  
  307.    return;
  308. }
  309.  
  310. void
  311. RefreshWindowAndGadgets(struct Window *wind)
  312. {
  313.     RefreshGadgets(wind->FirstGadget, wind,NULL);
  314.  
  315.    RefreshWindowFrame(wind);
  316.     GT_RefreshWindow( wind, NULL );
  317.  
  318.    return;
  319. }
  320.  
  321.     /*
  322.      * RefreshRastPort() malt das Hintergrundmuster und erneuert
  323.      * die Gadgets und deren Hintergrund
  324.      */
  325. void
  326. RefreshRastPort(struct Window *wind, struct Gadget **gads,
  327.                      int *gadnum, int cnt, int SaveGad,
  328.                 struct Gadget *GadgetList)
  329. {
  330.     struct RastPort *RP = wind->RPort;
  331.     struct Gadget *gad;
  332.     register int i;
  333.  
  334.    if(wind != SysWnd && (wind->Flags & WFLG_ZOOMED)) return;
  335.  
  336.    MakePattern(wind);
  337.  
  338.     if(bgc || bpc)
  339.     {
  340.         for(i = 0; i < cnt; i++) FillGadget( wind,gads[gadnum[i]], (BYTE)SaveGad );
  341.  
  342.         for(gad = gads[0]; gad; gad = gad->NextGadget)
  343.             if(gad->GadgetText)
  344.             {
  345.                 int pixlen = IntuiTextLength(gad->GadgetText);
  346.                 int x = gad->LeftEdge + gad->GadgetText->LeftEdge - 3,
  347.                      y = gad->TopEdge + gad->GadgetText->TopEdge - 2,
  348.                      w = pixlen + 6,
  349.                      h = gad->GadgetText->ITextFont->ta_YSize + 4;
  350.  
  351.                 EraseRect( wind->RPort,(long)x, (long)y, (long)(x + w - 1), (long)(y + h - 1));
  352.  
  353.                 DrawBevelBox( wind->RPort, x, y, w, h,
  354.                                   GTBB_Recessed, TRUE,
  355.                                   GT_VisualInfo, VisualInfo,
  356.                                   TAG_DONE );
  357.             }
  358.     }
  359.  
  360.    if(GadgetList) AddGList(wind, GadgetList, -1, -1, NULL);
  361.  
  362.    RefreshWindowAndGadgets(wind);
  363.  
  364.     if(Flags.autofront)
  365.     {
  366.         WindowToFront(wind);
  367.         ActivateWindow(wind);
  368.     }
  369.  
  370.     return;
  371. }
  372.  
  373.     /*
  374.      * RefreshMainWindowPattern() erneuert das Patternmuster
  375.      * des Hauptfensters von RSys
  376.      */
  377. void
  378. RefreshMainWindowPattern(void)
  379. {
  380.     int gl[] = {GD_ListeLV, GD_TextHeader, GD_InfoMsgGad};
  381.  
  382.    if(SysWnd) RefreshRastPort(SysWnd, SysGadgets, gl, 3, TRUE, NULL);
  383.  
  384.     return;
  385. }
  386.  
  387.     /*
  388.      * ClearIntuiMsgPort() beantwortet alle anliegenden Messages
  389.      * eines Windows
  390.      */
  391. void
  392. ClearIntuiMsgPort(struct Window *wnd)
  393. {
  394.     struct IntuiMessage *message;
  395.  
  396.     DPOS;
  397.  
  398.     while (message = (struct IntuiMessage *) GT_GetIMsg(wnd->UserPort)) GT_ReplyIMsg(message);
  399.  
  400.     return;
  401. }
  402.  
  403.     /*
  404.      * OpenMainWindow() öffnet das Hauptffenster
  405.      */
  406. void
  407. OpenMainWindow(void)
  408. {
  409.    int err;
  410.  
  411.     DPOS;
  412.  
  413.     if (!(err = SetupScreen()))
  414.    {
  415.       OpenASysWindow(OpenSysWindow, KILL);
  416.       return;
  417.    }
  418.  
  419.    if(err == 1) ErrorHandle((char *)namebuffer, SCREEN_ERR, LOCK_FAIL, KILL);
  420.    else
  421.        ErrorHandle((char *)"Visual info", SCREEN_ERR, INFO_FAIL, KILL);
  422.  
  423.     return;
  424. }
  425.  
  426.     /*
  427.      * CloseASysWindow() schließt ein von RSys verwaltetes Window
  428.      */
  429. void
  430. CloseASysWindow(struct Window **wind, struct Gadget **windgadlist, struct Menu **windmenus)
  431. {
  432.     DPOS;
  433.  
  434.    if(!(*wind)) return;
  435.  
  436.     if (windmenus && *windmenus)
  437.     {
  438.         ClearMenuStrip(*wind);
  439.         FreeMenus(*windmenus);
  440.         *windmenus = NULL;
  441.     }
  442.  
  443.     if (wind && *wind)
  444.     {
  445.         CloseWindow(*wind);
  446.         *wind = NULL;
  447.     }
  448.  
  449.     if (windgadlist && *windgadlist)
  450.     {
  451.         FreeGadgets(*windgadlist);
  452.         *windgadlist = NULL;
  453.     }
  454.  
  455.     return;
  456. }
  457.  
  458.     /*
  459.      * OpenASysWindow() öffnet ein Window mit einer
  460.      * vorzugebenden Funktion und mit einer allgemeinen
  461.      * Fehlerbehandlung
  462.      */
  463. int
  464. OpenASysWindow(int (*func) (void), int kill)
  465. {
  466.     ULONG failed = (*func) ();
  467.  
  468.     DPOS;
  469.  
  470.     switch (failed)
  471.     {
  472.         case 1L:
  473.             ErrorHandle("GadTools-Context", OBJECT_CONTEXT_ERR, CREATE_FAIL, kill);
  474.             break;
  475.  
  476.         case 2L:
  477.             ErrorHandle("CreateGadget()", GADGET_ERR, CREATE_FAIL, kill);
  478.             break;
  479.  
  480.         case 3L:
  481.             ErrorHandle("LayoutMenu()", MENU_ERR, CREATE_FAIL, kill);
  482.             break;
  483.  
  484.         case 4L:
  485.             ErrorHandle("OpenWindowTags()", WINDOW_ERR, OPEN_FAIL, kill);
  486.             break;
  487.     }
  488.  
  489.     return (failed ? FALSE : TRUE);
  490. }
  491.  
  492.     /*
  493.      * CenterWindow() ermittelt die Fensterposition, um das
  494.      * Fenster zentriert auf einem Screen erscheinen zu lassen
  495.      */
  496. void
  497. CenterWindow(struct Screen *scr, UWORD * top, UWORD * left,
  498.                  UWORD width, UWORD height)
  499. {
  500.     WORD    LE, TE;
  501.     WORD restwidth  = scr->Width    - width, restheight = scr->Height - height;
  502.  
  503.     DPOS;
  504.  
  505.     if (scr)
  506.     {
  507.         LE = (Flags.mousewindow ? scr->MouseX : (scr->Width  >> 1)) - (width  >> 1);
  508.         TE = (Flags.mousewindow ? scr->MouseY : (scr->Height >> 1)) - (height >> 1);
  509.  
  510.         *left = (LE < 0) ? (UWORD)0 : ((LE > restwidth ) ? restwidth  : LE);
  511.         *top    = (TE < 0) ? (UWORD)0 : ((TE > restheight) ? restheight : TE);
  512.     }
  513.  
  514.     return;
  515. }
  516.  
  517. void
  518. AdjustWindowDimensions(struct Screen *Scr,
  519.                        UWORD WinLeftEdge, UWORD WinTopEdge,
  520.                        UWORD WinWidth, UWORD WinHeight,
  521.                        UWORD *NewWinLeftEdge, UWORD *NewWinTopEdge,
  522.                        UWORD *NewWinWidth, UWORD *NewWinHeight)
  523. {
  524.    DPOS;
  525.  
  526.     ComputeFont(Scr, WinWidth, WinHeight);
  527.  
  528.     *NewWinWidth   = compute((UWORD) 0, FontX, (int)WinWidth);
  529.     *NewWinHeight  = compute((UWORD) 0, FontY, (int)WinHeight);
  530.  
  531.     if ((WinLeftEdge + *NewWinWidth + OffX + Scr->WBorRight) > Scr->Width)
  532.       *NewWinLeftEdge = Scr->Width - *NewWinWidth;
  533.  
  534.     if ((WinTopEdge + *NewWinHeight + OffY + Scr->WBorBottom) > Scr->Height)
  535.       *NewWinTopEdge = Scr->Height - *NewWinHeight;
  536.  
  537.     *NewWinWidth   = compute((UWORD) (OffX + Scr->WBorRight), FontX, (int)WinWidth);
  538.     *NewWinHeight  = compute((UWORD) (OffY + Scr->WBorBottom), FontY, (int)WinHeight);
  539.  
  540.     CenterWindow(Scr, NewWinTopEdge, NewWinLeftEdge, *NewWinWidth, *NewWinHeight);
  541.  
  542.    return;
  543. }
  544.  
  545.  
  546. /********************************************************************
  547.  *                                                                  *
  548.  *       ***************** Screen Routinen *****************        *
  549.  *                                                                  *
  550.  ********************************************************************/
  551.  
  552.     /*
  553.      * Die Funktion FindFrontPubScr() ermittelt
  554.      * bezüglich des aktuellen Screens, auf dem das
  555.      * Hauptfenster geöffnet wurde, den nächsten Public
  556.      * screen und gibt den Zeiger auf diesen zurück,
  557.      * falls dieser ungleich dem aktuellen und zugleich
  558.      * der vorderste Screen auf dem Bildschirm ist.
  559.      */
  560. struct Screen *
  561. FindFrontPubScr(struct Screen *activescr)
  562. {
  563.     char    newnamebuffer[MAXPUBSCREENNAME + 1];
  564.     UBYTE *test;
  565.     struct Screen *NewScr;
  566.  
  567.     DPOS;
  568.         /*
  569.          * Der Name des aktuellen Screens, auf dem RSys
  570.          * geöffnet wurde, wird gemerkt.
  571.          */
  572.     strncpy(newnamebuffer, (char *)namebuffer,MAXPUBSCREENNAME);
  573.  
  574.         /*
  575.          * Der Zeiger des neuen Screens wird initialisiert
  576.          * und der nächst Public screen ermittelt.
  577.          */
  578.     NewScr = NULL;
  579.     test = NextPubScreen(activescr, namebuffer);
  580.  
  581.         /*
  582.          * Solange der neue Screen nicht der vorderste
  583.          * Screen und nicht der aktuelle ist, und der neue
  584.          * Screen erfolgreich ermittelt werden konnte, wird
  585.          * dieser neue getestet. Im Erfolgsfall wird ein
  586.          * Zeiger auf diesen neuen Screen zurückgegeben.
  587.          */
  588.     while ((NewScr != IntuitionBase->FirstScreen) && (NewScr != activescr) && test)
  589.     {
  590.         NewScr = LockPubScreen(namebuffer);
  591.  
  592.         if ((NewScr == IntuitionBase->FirstScreen) && (NewScr != activescr))
  593.         {
  594.             UnlockPubScreen(NULL, NewScr);
  595.             return (NewScr);
  596.         }
  597.  
  598.         UnlockPubScreen(NULL, NewScr);
  599.  
  600.         test = NextPubScreen(NewScr, namebuffer);
  601.     }
  602.  
  603.         /*
  604.          * Wenn das Unterprogramm bis hierher kommt, konnte
  605.          * kein weiterer Public screen erkannt werden. Der
  606.          * gemerkte Screen name wird zurückkopiert und der
  607.          * Zeiger auf den aktiven Screen zurückgegeben.
  608.          */
  609.     strncpy((char *)namebuffer, newnamebuffer,MAXPUBSCREENNAME);
  610.  
  611.     return (activescr);
  612. }
  613.  
  614.     /*
  615.      * SetupScreen() ermittelt eine Zeiger auf den vordersten
  616.      * Screen. Ist der vorderste Screen kein PublicScreen,
  617.      * wird der WorkBench-Screen als Default-Screen genommen.
  618.      */
  619. long
  620. SetupScreen(void)
  621. {
  622.     extern struct Screen *lastpubscreen;
  623.  
  624.     DPOS;
  625.  
  626.     (void)FindFrontPubScr(lastpubscreen);
  627.  
  628.     if (NOT(Scr = LockPubScreen(namebuffer)))
  629.     {
  630.         strcpy((char *)namebuffer,"Workbench");
  631.         if (NOT(Scr = LockPubScreen(namebuffer))) return (1L);
  632.     }
  633.  
  634.     ComputeFont(Scr,(UWORD) 0, (UWORD) 0);
  635.  
  636.     if (NOT(VisualInfo = GetVisualInfo(Scr, TAG_DONE))) return (2L);
  637.  
  638.     lastpubscreen = Scr;
  639.  
  640.     return NULL;
  641. }
  642.  
  643.     /*
  644.      * CloseDownScreen() gibt den Screen frei, auf den ein
  645.      * RSys-Window geöffnet wurde.
  646.      */
  647. void
  648. CloseDownScreen(void)
  649. {
  650.     DPOS;
  651.  
  652.     if (VisualInfo)
  653.     {
  654.         FreeVisualInfo(VisualInfo);
  655.         VisualInfo = NULL;
  656.     }
  657.  
  658.     if (Scr)
  659.     {
  660.         UnlockPubScreen(NULL, Scr);
  661.         Scr = NULL;
  662.     }
  663.  
  664.     return;
  665. }
  666.  
  667.  
  668. /********************************************************************
  669.  *                                                                  *
  670.  *    ***************** Informations Routinen *****************     *
  671.  *                                                                  *
  672.  ********************************************************************/
  673.  
  674.     /*
  675.      * DisableSysRequest() unterdrückt die Anzeige von
  676.      * Systemrequestern, die beispielsweise nach einem Zugriff auf
  677.      * einen nicht existierenden Datenträger erscheinen
  678.      */
  679. void
  680. DisableSysRequest(int disable)
  681. {
  682.     static APTR wind;
  683.     struct Process *p = (struct Process *) FindTask(NULL);
  684.  
  685.     DPOS;
  686.  
  687.     if (disable)
  688.     {
  689.         wind = (APTR) p->pr_WindowPtr;
  690.         p->pr_WindowPtr = (APTR) (-1);
  691.     }
  692.     else p->pr_WindowPtr = wind;
  693.  
  694.     return;
  695. }
  696.  
  697.  
  698.  
  699.     /*
  700.      * PrintHeader() gibt einen Text im Titelfeld über dem
  701.      * Haupt-ListView aus
  702.      */
  703. void
  704. PrintHeader(enum ListTypes type, char *text)
  705. {
  706.     DPOS;
  707.  
  708.     LastID = type;
  709.  
  710.     GT_SetGadgetAttrs(SysGadgets[GD_TextHeader], SysWnd,
  711.                             NULL,
  712.                             GTTX_Text, (UBYTE *) (NOT(text) ? EntryAttr[type].ea_header : text),
  713.                             TAG_DONE);
  714.  
  715.     return;
  716. }
  717.  
  718.     /*
  719.      * PrintInfo() gibt einen Text im Messagefeld vom Hauptfenster
  720.      * aus. Falls der Sprachmodus aktiviert ist und der Text
  721.      * gesprochen werden soll, wird er zusätzlich auf dem
  722.      * Narrator-Device ausgegeben
  723.      */
  724. void
  725. PrintInfo(char *text, int speakit,int waitit)
  726. {
  727.     static char help[BUFSIZE];
  728.     int    i,
  729.             len = strlen(text),
  730.             fill = ((BUFSIZE - len) >> 1);
  731.  
  732.     DPOS;
  733.  
  734.    if(!SysWnd || SysWnd->FirstRequest) return;
  735.  
  736.     for (i = 0; i < fill; i++) help[i] = ' ';
  737.  
  738.     help[fill] = STRINGEND;
  739.  
  740.     strcat(help, text);
  741.  
  742.     GT_SetGadgetAttrs(SysGadgets[GD_InfoMsgGad], SysWnd,
  743.                             NULL,
  744.                             GTTX_Text, (UBYTE *) help,
  745.                             TAG_DONE);
  746.  
  747.     if (NOT(Flags.fastmode)) WaitTOF();
  748.  
  749.     if (Flags.speakmode && speakit) Speak(help);
  750.  
  751.     if (waitit != 0) Delay(waitit);
  752.  
  753.     return;
  754. }
  755.  
  756.     /*
  757.      * PrintStatistics() gibt für bestimmte Listen eine
  758.      * Zusammenfasung (Anzahl der ermittelten Einträge) aus
  759.      */
  760. void
  761. PrintStatistics(void)
  762. {
  763.     char    help[BUFSIZE], *type = EntryAttr[LastID].ea_type;
  764.  
  765.     DPOS;
  766.  
  767.    if (!SysWnd || SysWnd->FirstRequest) return;
  768.  
  769.     if (countentries == 0) sprintf(help, "No %s entries read", type);
  770.     else
  771.         if (EntryAttr[LastID].ea_counted) sprintf(help, "%ld %s entries read", countentries,type);
  772.         else
  773.             sprintf(help, "%s entries read", type);
  774.  
  775.     PrintInfo(help, SPEAK, 0);
  776.  
  777.     RefreshListView();
  778.  
  779.     return;
  780. }
  781.  
  782.     /*
  783.      * MyEasyRequest() erzeugt nach Vorgaben einen
  784.      * System-Standard-Requester
  785.      */
  786. WORD
  787. MyEasyRequest(struct Window * wind, UBYTE * title,
  788.                   UBYTE * Gadgets, UBYTE * Body,...)
  789. {
  790.     struct EasyStruct Easy;
  791.     WORD    Result;
  792.     va_list VarArgs;
  793.     APTR    req;
  794.  
  795.     DPOS;
  796.  
  797.     Easy.es_StructSize = sizeof(struct EasyStruct);
  798.  
  799.     Easy.es_Flags        = NULL;
  800.     Easy.es_Title        = title;
  801.     Easy.es_TextFormat   = Body;
  802.     Easy.es_GadgetFormat = Gadgets;
  803.  
  804.     req = LockWindow(wind);
  805.  
  806.     va_start(VarArgs, Body);
  807.     Result = EasyRequestArgs(wind, &Easy, NULL, VarArgs);
  808.     va_end(VarArgs);
  809.  
  810.     UnlockWindow(req);
  811.  
  812.     return Result;
  813. }
  814.  
  815.